// utils/request.js
import axios from "axios";
import CryptoJS from 'crypto-js';

// 环境配置
// todo 1.
// export const FE_HOME_URL = 'http://10.9.139.14:8084/lifepolifyfe/#/';
// export const FE_HOME_URL = 'http://localhost:8082/#/';
// export const FE_HOME_URL = 'https://txwechat.sinosig.com/sunshineweb/lifepolifyfe/#/';
export const FE_HOME_URL = 'https://grpwechat.sinosig.com/sunshineweb/lifepolifyfe/#/';

// AES 配置
const aesKey = '4d3c2a1b5e6f7a8b9c0d1e2f3a4b5c6d';

/**
 * 创建请求实例
 */
const apiClient = axios.create({
    // baseURL: 'http://localhost:8083',
    // baseURL: "http://10.136.96.119:8081",
    // baseURL: "http://localhost:8081",
    // baseURL: "http://10.9.139.14:8081",
    // // todo 2.
    // baseURL: "https://txwechat.sinosig.com",
    // 生产
    baseURL: "https://grpwechat.sinosig.com",
    timeout: 5000,
    headers: {
        "Content-Type": "application/json"
    }
});
/**
 * 加密工具类
 */
const cryptoUtils = {
    encryptData(data) {
        try {
            // 将数据转换为 JSON 字符串
            const jsonData = JSON.stringify(data);
            console.info("Original data:", jsonData);

            // 将密钥转换为 WordArray
            const key = CryptoJS.enc.Utf8.parse(aesKey);

            // 使用 AES ECB 模式和 PKCS7 填充进行加密
            const encrypted = CryptoJS.AES.encrypt(jsonData, key, {
                mode: CryptoJS.mode.ECB,
                padding: CryptoJS.pad.Pkcs7
            });

            // 获取加密后的字节数组并转换为十六进制
            const ciphertext = encrypted.ciphertext;
            const hexString = ciphertext.toString().toUpperCase();
            console.info("Encrypted hex:", hexString);

            return hexString;
        } catch (error) {
            console.error('Encryption error:', error);
            throw error;
        }
    },

    decryptData(encryptedHex) {
        try {
            console.info("Encrypted hex received:", encryptedHex);

            // 将密钥转换为 WordArray
            const key = CryptoJS.enc.Utf8.parse(aesKey);

            // 将十六进制字符串转换为 CipherParams 对象
            const ciphertext = CryptoJS.enc.Hex.parse(encryptedHex);
            const cipherParams = CryptoJS.lib.CipherParams.create({
                ciphertext: ciphertext
            });

            // 解密
            const decrypted = CryptoJS.AES.decrypt(cipherParams, key, {
                mode: CryptoJS.mode.ECB,
                padding: CryptoJS.pad.Pkcs7
            });

            // 转换为字符串
            const decryptedStr = decrypted.toString(CryptoJS.enc.Utf8);
            console.info("Decrypted string:", decryptedStr);

            // 尝试解析为 JSON
            return JSON.parse(decryptedStr);
        } catch (error) {
            console.error('Decryption error:', error);
            throw error;
        }
    }
};

/**
 * 封装请求方法
 * @param {Object} config 请求配置
 * @returns {Promise} 请求Promise
 */
function request(config) {
    // 处理请求数据
    if (config.data) {
        console.log('Request data before encryption:', config.data);
        config.data = cryptoUtils.encryptData(config.data);
        console.log('Request data after encryption:', config.data);
    } else if (config.method.toLowerCase() === 'post') {
        // 如果是 POST 请求但没有数据，发送空对象
        config.data = cryptoUtils.encryptData({});
    }

    return apiClient(config).then(response => {
        // 处理响应数据
        if (response.data && typeof response.data === 'string') {
            try {
                const result = cryptoUtils.decryptData(response.data);
                console.info("result:" + result);
                console.log('result:', result);
                response.data = result;
            } catch (error) {
                console.error('Response decryption failed:', error);
                return response.data;
            }
        }
        return response.data;
    }).catch(error => {
        console.error('Request failed:', error);
        throw error;
    });
}


const typeUtils = {
    // 方法1：使用 typeof
    isString(data) {
        return typeof data === 'string';
    },

    // 方法2：使用 instanceof
    isObject(data) {
        return data instanceof Object && !Array.isArray(data);
    },

    // 方法3：使用 Object.prototype.toString
    getType(data) {
        return Object.prototype.toString.call(data);
    },

    // 方法4：综合判断
    checkType(data) {
        if (data === null) return 'null';
        if (data === undefined) return 'undefined';
        return Object.prototype.toString.call(data).slice(8, -1).toLowerCase();
    }
};

export default request;
